/**
 * Project: alimail.common
 * 
 * File Created at 2010-1-7
 * $Id$
 * 
 * Copyright 2008 shensuoyao.com Croporation Limited.
 * All rights reserved.
 *
 * This software is the confidential and proprietary information of
 * shensuoyao Company. ("Confidential Information").  You shall not
 * disclose such Confidential Information and shall use it only in
 * accordance with the terms of the license agreement you entered into
 * with shensuoyao.com.
 */
package com.ssy.invoicing.common.util;
 
import java.io.UnsupportedEncodingException;
import java.net.URLEncoder;
import java.text.MessageFormat;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import org.apache.commons.lang.StringEscapeUtils;
import org.apache.commons.lang.StringUtils;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
 * 字符串处理
 * 
 * @author hongqing.huang
 */
public class StringUtil {
    static Logger logger = LoggerFactory.getLogger(StringUtil.class);

    /** 空格内容：半角空格，全角空格（中文），后续如果还有其它语言版本则添加新的空格 */
    private static final char[] ALL_BLANK = { ' ', '　' };

    /** 日志处理 */
    //private static Logger      log = LoggerFactory.getLogger(StringUtil.class);
    /**
     * 检查字符串是否为<code>null</code>或空字符串<code>""</code>。
     * 
     * <pre>
     * StringUtil.isEmpty(null)      = true
     * StringUtil.isEmpty("")        = true
     * StringUtil.isEmpty(" ")       = false
     * StringUtil.isEmpty("bob")     = false
     * StringUtil.isEmpty("  bob  ") = false
     * </pre>
     * 
     * @param str 要检查的字符串
     * @return 如果为空, 则返回<code>true</code>
     */
    public static boolean isEmpty(String str) {
        return ((str == null) || (str.length() == 0));
    }

    
    
    /**
     * 计算输入字符串的长度 null return 0<br>
     * 中文字符将被换成两个英文再进行计算
     * 
     * @param data
     * @return int 字节长度
     */
    public static int byteSize(String data) {
        int count = 0;
        if (StringUtils.isEmpty(data))
            return count;

        char[] chs = data.toCharArray();
        for (int i = 0; i < chs.length; i++) {
            count += (chs[i] > 0xff) ? 2 : 1;
        }

        return count;
    }

    /**
     * 对输入数据进行字节（UTF-8编码）长度校验<br/>
     * 备注：中文字符将被换成 "xx"再进行计算，中文字符按照2位<br/>
     * 
     * @param data 数据
     * @param maxLength 最大长度
     * @return boolean true 输入数据字节长度不超过最大长度，否则返回false
     */
    public static boolean checkMaxByteLength(String data, int maxLength) {
        if (maxLength <= 0 || StringUtils.isEmpty(data)) {
            return true;
        }
        int length = byteSize(data);

        if (length <= maxLength) {
            return true;
        } else {
            return false;
        }
    }

    /**
     * 对输入的数据进行截取，按照如下方式进行。<br/>
     * 1. 如果指定数据为null或者空字符串或者指定长度小与等于0，返回空字符串 <br/>
     * 2. 如果指定的数据长度小于等于指定的最大字符长度(中文或者全角数据按照1个字母计算)，则不做截取直接返回<br/>
     * 3. 如果指定的数据长度大于指定的最大字节长度，则截取到最大长度，然后后面根指定数目的逗号<br/>
     * 4. 前端指定会多留一个逗号的位置，所以这边计算显示大小的时候，逗号总是－1；<br/>
     * 5. 由于2个半角逗号的显示宽度和一个中文差不多，所以换算的时候，2个半角＝一个中文
     * 
     * @param data 字符串数据
     * @param maxLength 最大长度
     * @param ditCnt 点号的数量
     * @return String 返回的数据
     */
    public static String intercept(String data, int maxLength, int ditCnt) {
        if (StringUtils.isEmpty(data) || maxLength <= 0) {
            return "";
        }
        int length = data.length();
        if (length <= maxLength) {
            return data;
        }
        if (ditCnt <= 0) {
            return data.substring(0, maxLength);
        }
        ditCnt--;
        int chineseCharCnt = (ditCnt) % 2;
        if (ditCnt > (chineseCharCnt * 2)) {
            chineseCharCnt++;
        }

        StringBuilder retData = new StringBuilder(data.substring(0, maxLength - chineseCharCnt));
        // 前面的逗号－1，所以这里变成<=
        for (int i = 0; i <= ditCnt; i++) {
            retData.append(".");
        }

        return retData.toString();

    }

    /**
     * 按照设定的长度截取前缀 如“这是一个很长的字符串.doc阿斯顿发.doc”，截取为“这是一个很长的字符串.doc阿....doc”
     * 如果没有后缀，按照intercept处理
     * 
     * @param data
     * @param maxLength
     * @param ditCnt
     * @return
     */
    public static String interceptPrefix(String data, int maxLength, int ditCnt) {
        int index = data.lastIndexOf(".");
        if (index >= 0) {
            String prefix = data.substring(0, index);
            return intercept(prefix, maxLength, ditCnt).concat(data.substring(index));
        }
        return intercept(data, maxLength, ditCnt);
    }

    /**
     * 去除数据前后的空格（半角空格，中文全角空格） 如果输入数据为null，则返回null
     * 
     * @param data 数据
     * @return String 去除前后空格之后的数据
     */
    public static String trimAllBlank(String data) {
        if (StringUtils.isEmpty(data)) {
            return data;
        }
        int count = data.length();
        int len = count;
        int st = 0;
        int off = 0;
        char[] val = data.toCharArray();

        while ((st < len) && isBlank(val[off + st])) {
            st++;
        }
        while ((st < len) && isBlank(val[off + len - 1])) {
            len--;
        }
        return ((st > 0) || (len < count)) ? data.substring(st, len) : data;
    }

    /**
     * 对指定的字符串url encoder
     * 
     * @param data 数据
     * @return String 编码后的数据
     */
    public static String encode(String data, String... charset) {
        if (StringUtils.isEmpty(data)) {
            return data;
        }

        String cs = "";
        if (charset.length == 1)
            cs = charset[0];
        if (charset.length > 1 || charset.length == 0)
            cs = "UTF-8";

        try {
            return URLEncoder.encode(data, cs);
        } catch (UnsupportedEncodingException e) {
            return data;
        }
    }

    /**
     * 将字符串中的html转义.
     * 
     * @param data 数据
     * @return String 转义后的数据
     */
    public static String convertHtmlToString(String data) {
        if (StringUtils.isEmpty(data)) {
            return data;
        }
        return StringEscapeUtils.escapeHtml(data);
    }

    /**
     * 判断指定的字符是否是空格（半角空格，中文全角空格）
     * 
     * @param data 字符数据
     * @return boolean true 是空格，false 不是空格
     */
    private static boolean isBlank(char data) {
        for (int i = 0; i < ALL_BLANK.length; i++) {
            if (data == ALL_BLANK[i]) {
                return true;
            }
        }
        return false;
    }

    /**
     * 按照UTF-8编码，计算指定的字符串字节长度
     * 
     * @param data 字符串数据
     * @return 字节长度，如果为空或者出现异常则返回0
     */
    public static int getBytesSize(String data) {
        if (StringUtils.isEmpty(data)) {
            return 0;
        }

        try {
            return data.getBytes("utf-8").length;
        } catch (UnsupportedEncodingException e) {
            return 0;
        }
    }

    /** 判断是否为空 ***/
    public static String defaultIfEmpty(String str, String defaultStr) {
        return ((str == null) || (str.length() == 0)) ? defaultStr : str;
    }

    /**
     * 对输入的文件名进行截取并URLEncoder，按照如下方式进行。<br/>
     * 1. 如果指定数据为null或者空字符串或者指定长度小与等于0，返回空字符串 <br/>
     * 2. 如果指定的数据长度小于等于指定的最大字符长度(中文或者全角数据按照1个字母计算)，则不做截取直接返回<br/>
     * 3. 如果指定的数据长度大于指定的最大字节长度，则截取到最大长度，然后后面根指定数目的逗号<br/>
     * 4. 前端指定会多留一个逗号的位置，所以这边计算显示大小的时候，逗号总是－1；<br/>
     * 5. 由于2个半角逗号的显示宽度和一个中文差不多，所以换算的时候，2个半角＝一个中文
     * 
     * @param file 字符串数据
     * @param maxLength 最大长度
     * @param ditCnt 点号的数量
     * @return String 返回的数据
     */
    public static String interceptAndEncodeAttachName(String file, int maxLength,
                                                      int fileTypeMaxLength, int ditCnt) {
        if (StringUtils.isEmpty(file) || maxLength <= 0) {
            return "";
        }

        String fileName = "";
        String fileType = "";
        if (file.lastIndexOf(".") > 0) {
            fileType = file.substring(file.lastIndexOf(".") + 1);
            if (fileType.getBytes().length == fileType.length())
                fileName = file.substring(0, file.lastIndexOf("."));
            else {
                fileType = "";
                fileName = file;
            }
        } else {
            fileName = file;
        }

        fileName = intercept(fileName, maxLength, ditCnt);
        fileType = intercept(fileType, fileTypeMaxLength, 0);

        String result = "";
        try {
            if (StringUtils.isEmpty(fileType))
                result = URLEncoder.encode(fileName, "utf-8");
            else
                result = URLEncoder.encode(fileName + "." + fileType, "utf-8");
            //result.replaceAll("\\+", "%20");
        } catch (UnsupportedEncodingException e) {
        }

        return result;
    }

    /**
     * 给邮件标题、概要中的关键字高亮
     * 
     * @param String 原文字
     * @return String 高亮后的文字
     */
    public static String setHightLight(String original) {
        if (!StringUtils.isEmpty(original)) {
            return original.replaceAll("\t([^\t]*)\t", "<span class=\"highlight\">$1</span>");
        } else {
            return original;
        }

    }
    
     /**
     * 关键字搜索去掉主题特殊字符\t
     * 
     * @param String 原文字
     * @return String 去除后的文字
     */
    public static String removeCharacters(String original) {
        if (!StringUtils.isEmpty(original)) {
            return original.replaceAll("\t([^\t]*)\t", "$1");
        } else {
            return original;
        }
    }

    /**
     * 替换字符串,如: fomat("该{0}还有邮件，请先{1}后删除", new String[]{"帐户", "清空邮件"}) ->
     * 该帐户内还有邮件，请先清空邮件后删除
     * 
     * @param str 格式字符串
     * @param paras 要替换字符串;
     * @return
     */
    public static String format(String str, String... paras) {
        return new MessageFormat(str).format(paras);
    }
    
    /**
     * 判断给定数组中是否有空值
     * @param strs
     * @return
     */
    public static boolean hasEmtpyString(String[] strs){
        boolean hasEmptyStr = false;
        if(strs != null && strs.length > 0){
            for(String str : strs){
                if(StringUtils.isBlank(str)){ 
                    hasEmptyStr = true;
                    break;
                }
            }
        }
        return hasEmptyStr;
    }

    public static String arrayToString(String[] object){
    	 String s=Arrays.toString(object);
  	     s=s.replaceAll("\\[|\\]", "");
  	     return s;
    }
    
    public static boolean equals(String s1,String s2){
    	if(toString(s1).equals(toString(s2))){
    		return true;
    	}
    	return false;
    }
    public static String toString(String str){
    	if(str==null)
    		return "";
    	else
    		return str;
    }
    
    public static String toString(Object str){
    	if(str==null)
    		return "";
    	else
    		return str.toString();
    }
	
	public static String toJsonArrayString(List<String> jsonStrList)throws Exception{
		StringBuffer buffer=new StringBuffer();
		String s="[",e="]";
		buffer.append(s);
		if(jsonStrList.size()>0){
			for(int i=0;i<jsonStrList.size();i++){
				String unit=jsonStrList.get(i);
				if(i==0){
					buffer.append(unit);
				}else{
					buffer.append(",").append(unit);
				}
			}
		}
		buffer.append(e);
		return buffer.toString();
	}
	
	public static boolean isNullOrEmpty(Object object){
		if(object==null){
			return true;
		}else if(object.toString().trim().trim().equals(""))
			return true;
		return false;
	}
	
	/**
	 * 检查String是否为Email类型
	 * @author wb_suoyao.shen 2012.04.11
	 * @param mail
	 * @return
	 */
	public static boolean checkEmail(String mail){
	    String regex = "\\w+([-+.]\\w+)*@\\w+([-.]\\w+)*\\.\\w+([-.]\\w+)*";
	    Pattern p = Pattern.compile(regex);
	    Matcher m = p.matcher(mail);
	    return m.find();
	}
	
	/**
	 * 判断是否要从远程数据库查询
	 * @param str
	 * @return
	 */
	public static boolean isRemoteQuery(String str) {
	    if ("OPERATOR_ACCOUNT_TOTAL".equals(str)) 
	        return true;
	    if ("OPERATOR_DOMAIN_TOTAL".equals(str)) 
	        return true;
	    if ("OPERATOR_STORAGE_TOTAL".equals(str)) 
	        return true;
	    return false;
	}
	
	public static void main(String[] args) {
        /*String[] pinyinArray = PinyinHelper.toHanyuPinyinStringArray('单');
        for (int i = 0; i < pinyinArray.length; ++i) {
            System.out.println(pinyinArray[i]);
        }*/
	    System.out.println(checkEmail("qa1@synztec-sha.com.cn"));
	}
	
}
